import java.util.*;

import javafx.util.Pair;
/*
给定一个整数 n，将数字 1∼n排成一排，将会有很多种排列方法。
现在，请你按照字典序将所有的排列方法输出。

输入格式
共一行，包含一个整数 n。

输出格式
按字典序输出所有排列方案，每个方案占一行。

数据范围
1≤n≤7

输入样例：
3

输出样例：
1 2 3
1 3 2
2 1 3
2 3 1
3 1 2
3 2 1
 */
//public class Main {
//    static ArrayList<Integer> path = new ArrayList<>();
//    static boolean[] visited = new boolean[10];
//
//    static void DFS(int n) {
//        if (path.size() == n) {
//            for (int j = 0; j < n; j++)
//                System.out.print(path.get(j) + " ");
//            System.out.println();
//            return;
//        }
//        for (int i = 1; i <= n; i++) {
//            if (!visited[i]) {
//                path.add(i);
//                visited[i] = true;
//                DFS(n);
//                visited[i] = false;
//                path.remove(path.size() - 1);
//            }
//        }
//    }
//
//    public static void main(String[] args) {
//        Scanner sc = new Scanner(System.in);
//        DFS(sc.nextInt());
//    }
//}

/*
n−皇后问题是指将 n个皇后放在 n×n的国际象棋棋盘上，使得皇后不能相互攻击到，即任意两个皇后都不能处于同一行、同一列或同一斜线上。
现在给定整数 n，请你输出所有的满足条件的棋子摆法。

输入格式
共一行，包含整数 n。

输出格式
每个解决方案占 n行，每行输出一个长度为 n的字符串，用来表示完整的棋盘状态。
其中 . 表示某一个位置的方格状态为空，Q 表示某一个位置的方格上摆着皇后。
每个方案输出完成后，输出一个空行。
注意：行末不能有多余空格。
输出方案的顺序任意，只要不重复且没有遗漏即可。

数据范围
1≤n≤9

输入样例：
4

输出样例：
.Q..
...Q
Q...
..Q.

..Q.
Q...
...Q
.Q..
 */
//public class Main {
//    static int n;
//    static char[][] map = new char[20][20];
//    static boolean[] col = new boolean[20],dg = new boolean[20],ndg = new boolean[20];
//    static void printMap() {
//        for (int i = 0; i < n; i++) {
//            for (int j = 0; j < n; j++) {
//                System.out.print(map[i][j]);
//                if(j<n-1)System.out.print(" ");
//            }
//            System.out.println();
//        }
//        System.out.println();
//    }
//    static void DFS(int row)
//    {
//        if(row == n)
//        {
//            printMap();
//            return;
//        }
//        for (int i = 0; i < n; i++) {
//            if(!col[i]&&!dg[i+row]&&!ndg[i-row+n])
//            {
//                col[i] = dg[i+row] =ndg[i-row+n] = true;
//                map[row][i] = 'Q';
//                DFS(row+1);
//                map[row][i] = '.';
//                col[i] = dg[i+row]=ndg[i-row+n]=false;
//            }
//        }
//    }
//    public static void main(String[] args) {
//        Scanner sc = new Scanner(System.in);
//        n=sc.nextInt();
//        for (int i = 0; i < n; i++) {
//            for (int j = 0; j < n; j++) {
//                map[i][j] = '.';
//            }
//        }
//        DFS(0);
//        //printMap();
//    }
//}

/// /用邻接表存储图，并DFS,BFS
//public class Main {
//    static ArrayList<ArrayList<Integer>> graph = new ArrayList<>();
//    static int n;//点数
//    static int m;//边数
//    static boolean[] visited = new boolean[100010];
//
//    static void addEdge(int from, int to) {
//        graph.get(from).add(to);
//    }
//
//    static void DFS(int v) {
//        System.out.print(v + " ");
//        visited[v] = true;
//        for (int w : graph.get(v)) {
//            if (!visited[w]) {
//                DFS(w);
//            }
//        }
//    }
//
//    static void BFS(int v) {
//        Queue<Integer> q = new LinkedList<>();
//        q.add(v);
//        while (!q.isEmpty()) {
//            int w = q.poll();
//            visited[w] = true;
//            System.out.print(w + " ");
//            for (int x : graph.get(w)) {
//                if (!visited[x]) {
//                    q.add(x);
//                }
//            }
//        }
//    }
//
//    public static void main(String[] args) {
//        Scanner sc = new Scanner(System.in);
//        n = sc.nextInt();
//        for (int i = 0; i < 100010; i++) {
//            graph.add(new ArrayList<>());
//        }
//        m = sc.nextInt();
//        for (int i = 0; i < m; i++) {
//            int from = sc.nextInt(), to = sc.nextInt();
//            addEdge(from, to);
//            addEdge(to, from);
//        }
//        //DFS(1);
//        BFS(1);
//    }
//}

/*
给定一颗树，树中包含 n个结点（编号 1∼n）和 n−1 条无向边。
请你找到树的重心，并输出将重心删除后，剩余各个连通块中点数的最大值。
重心定义：重心是指树中的一个结点，如果将这个点删除后，剩余各个连通块中点数的最大值最小，那么这个节点被称为树的重心。

输入格式
第一行包含整数 n，表示树的结点数。
接下来 n−1行，每行包含两个整数 a和 b，表示点 a和点 b之间存在一条边。

输出格式
输出一个整数 m，表示将重心删除后，剩余各个连通块中点数的最大值。

数据范围
1≤n≤1e5

输入样例
9
1 2
1 7
1 4
2 8
2 5
4 3
3 9
4 6

输出样例：
4
 */

public class Main {
    static int n;//点数
    static ArrayList<ArrayList<Integer>> graph = new ArrayList<>();
    static boolean[] visited = new boolean[10010];

    static void addEdge(int v, int w) {
        graph.get(v).add(w);
    }

    static int minMaxVal = Integer.MAX_VALUE;

    static int DFS(int v) {
        int sum = 1;//表示以v为根的树的节点数
        int maxVal = 0;//表示除了点v所有连通块的点数最大值
        visited[v] = true;
        for (int w : graph.get(v)) {
            if (!visited[w]) {
                int res = DFS(w);
                sum += res;
                maxVal = Math.max(maxVal, res);
            }
        }
        maxVal = Math.max(maxVal, n - sum);
        minMaxVal = Math.min(minMaxVal, maxVal);
        return sum;
    }

    public static void main(String[] args) {
        Scanner sc = new Scanner(System.in);
        n = sc.nextInt();
        for (int i = 0; i < 10010; i++) {
            graph.add(new ArrayList<>());
        }
        for (int i = 0; i < n - 1; i++) {
            int v = sc.nextInt(), w = sc.nextInt();
            addEdge(v, w);
            addEdge(w, v);
        }
        int a = DFS(1);//a无用
        System.out.println(minMaxVal);
    }
}